{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# cnn-mnist\n",
    "使用tensorflow，构造并训练一个神经网络，在测试机上达到超过98%的准确率。 \n",
    "作业详情：https://gitee.com/ai100/quiz-w7-1-cnn-mnist "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'channels_last'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"A very simple MNIST classifier.\n",
    "See extensive documentation at\n",
    "https://www.tensorflow.org/get_started/mnist/beginners\n",
    "\"\"\"\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import argparse\n",
    "import sys\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "from keras.layers.core import Dense, Flatten\n",
    "from keras.layers.convolutional import Conv2D\n",
    "from keras.layers.pooling import MaxPooling2D\n",
    "from keras import initializers\n",
    "\n",
    "from keras import backend as K\n",
    "\n",
    "K.image_data_format() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在这里调用系统提供的Mnist数据函数为我们读入数据，如果没有下载的话则进行下载。\n",
    "\n",
    "<font color=#ff0000>**这里将data_dir改为适合你的运行环境的目录**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-698ada706af1>:3: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\t10k-images-idx3-ubyte.gz\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n"
     ]
    }
   ],
   "source": [
    "# Import data\n",
    "data_dir = '/tmp/tensorflow/mnist/input_data'\n",
    "mnist = input_data.read_data_sets(data_dir, one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义输入输出\n",
    "x = tf.placeholder(tf.float32, [None, 784])\n",
    "y_ = tf.placeholder(tf.float32, [None, 10])\n",
    "# 学习速率\n",
    "learning_rate = tf.placeholder(tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('reshape'):\n",
    "  x_image = tf.reshape(x, [-1, 28, 28, 1])\n",
    "\n",
    "\n",
    "# 二维卷积层，即对图像的空域卷积。\n",
    "# keras.layers.convolutional.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, \n",
    "#                                  dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_uniform', \n",
    "#                                  bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, \n",
    "#                                  activity_regularizer=None, kernel_constraint=None, bias_constraint=None)\n",
    "# filters：卷积核的数目（即输出的维度）\n",
    "# kernel_size：卷积核的宽度和长度。如为单个整数，则表示在各个空间维度的相同长度。\n",
    "# strides：卷积的步长。如为单个整数，则表示在各个空间维度的相同步长。\n",
    "# activation：激活函数，如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）\n",
    "# padding：补0策略，为“valid”, “same” 。\n",
    "# use_bias:布尔值，是否使用偏置项\n",
    "# kernel_initializer：权值初始化方法\n",
    "# bias_initializer：权值初始化方法\n",
    "# kernel_regularizer：施加在权重上的正则项\n",
    "# bias_regularizer：施加在偏置向量上的正则项\n",
    "# activity_regularizer：施加在输出上的正则项\n",
    "# kernel_constraints：施加在权重上的约束项\n",
    "# bias_constraints：施加在偏置上的约束项\n",
    "\n",
    "# 卷积层1\n",
    "net = Conv2D(32, kernel_size=[5,5], strides=[1,1], activation='sigmoid', padding='same',\n",
    "             kernel_initializer = 'glorot_normal', \n",
    "             bias_initializer = initializers.Constant(value=0.01), \n",
    "             input_shape=[28,28,1])(x_image)  \n",
    "# 第一层卷积必须显示指定input_shape输入数据形状[高，宽，通道数]\n",
    "# Conv2D 是类方法，第一层时需传递输入数据x_image\n",
    "\n",
    "# 最大值池化层\n",
    "# keras.layers.pooling.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)\n",
    "# pool_size：代表在两个方向（竖直，水平）上的下采样因子，如取（2，2）将使图片在两个维度上均变为原长的一半。\n",
    "# strides：步长值\n",
    "# border_mode：‘valid’或者‘same’\n",
    "# data_format：“channels_first”或“channels_last”之一，代表图像的通道维的位置。以128x128的RGB图像为例，\n",
    "#              “channels_first”应将数据组织为（3,128,128），而“channels_last”应将数据组织为（128,128,3）。\n",
    "\n",
    "# 池化层1\n",
    "net = MaxPooling2D(pool_size=[2,2])(net) # 池化\n",
    "\n",
    "#卷积层2\n",
    "net = Conv2D(64, kernel_size=[5,5], strides=[1,1],activation='sigmoid', padding='same', \n",
    "             kernel_initializer = 'glorot_normal',  # Glorot正态分布初始化方法，也称作Xavier正态分布初始化\n",
    "             bias_initializer = initializers.Constant(value=0.01))(net)\n",
    "\n",
    "# 池化层2\n",
    "net = MaxPooling2D(pool_size=[2,2])(net)\n",
    "\n",
    "# Flatten层，用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。Flatten不影响batch的大小。\n",
    "net = Flatten()(net) \n",
    "\n",
    "# 全连接层\n",
    "# keras.layers.core.Dense(units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', \n",
    "#                         bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, \n",
    "#                         activity_regularizer=None, kernel_constraint=None, bias_constraint=None)\n",
    "# units：大于0的整数，代表该层的输出维度\n",
    "# activation：激活函数，如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）\n",
    "# use_bias: 布尔值，是否使用偏置项\n",
    "# kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器\n",
    "# bias_initializer：偏置向量初始化方法，为预定义初始化方法名的字符串，或用于初始化偏置向量的初始化器\n",
    "# kernel_regularizer：施加在权重上的正则项\n",
    "# bias_regularizer：施加在偏置向量上的正则项\n",
    "# activity_regularizer：施加在输出上的正则项\n",
    "# kernel_constraints：施加在权重上的约束项\n",
    "# bias_constraints：施加在偏置上的约束项\n",
    "\n",
    "# 全连接层1\n",
    "net = Dense(1000, activation='relu')(net) # 全连接层\n",
    "\n",
    "# 全连接层2\n",
    "net = Dense(10,activation='softmax')(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算交叉熵\n",
    "from keras.objectives import categorical_crossentropy\n",
    "cross_entropy = tf.reduce_mean(categorical_crossentropy(y_, net)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2_loss = tf.add_n( [tf.nn.l2_loss(w) for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)] )\n",
    "#惩罚因子\n",
    "regularization_rate = 7e-5\n",
    "total_loss = cross_entropy + regularization_rate * l2_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(total_loss)\n",
    "sess = tf.Session()\n",
    "K.set_session(sess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 100, entropy loss: 2.109473, l2_loss: 790.284241, total loss: 2.164793, accuracy: 0.590000\n",
      "step 200, entropy loss: 0.824563, l2_loss: 792.100830, total loss: 0.880010, accuracy: 0.820000\n",
      "step 300, entropy loss: 0.545977, l2_loss: 793.417847, total loss: 0.601516, accuracy: 0.900000\n",
      "step 400, entropy loss: 0.528890, l2_loss: 794.046814, total loss: 0.584473, accuracy: 0.870000\n",
      "step 500, entropy loss: 0.388705, l2_loss: 794.401794, total loss: 0.444314, accuracy: 0.940000\n",
      "step 500, 训练误差:  0.901000\n",
      "step 500, 测试误差:  0.906800\n",
      "step 600, entropy loss: 0.357911, l2_loss: 794.735474, total loss: 0.413543, accuracy: 0.920000\n",
      "step 700, entropy loss: 0.178624, l2_loss: 795.001526, total loss: 0.234274, accuracy: 0.970000\n",
      "step 800, entropy loss: 0.231935, l2_loss: 795.245056, total loss: 0.287603, accuracy: 0.940000\n",
      "step 900, entropy loss: 0.266338, l2_loss: 795.449768, total loss: 0.322019, accuracy: 0.940000\n",
      "step 1000, entropy loss: 0.141170, l2_loss: 795.660645, total loss: 0.196866, accuracy: 0.960000\n",
      "step 1000, 训练误差:  0.939873\n",
      "step 1000, 测试误差:  0.945600\n",
      "step 1100, entropy loss: 0.196620, l2_loss: 795.834534, total loss: 0.252328, accuracy: 0.950000\n",
      "step 1200, entropy loss: 0.161877, l2_loss: 795.982056, total loss: 0.217595, accuracy: 0.970000\n",
      "step 1300, entropy loss: 0.189796, l2_loss: 796.159485, total loss: 0.245527, accuracy: 0.940000\n",
      "step 1400, entropy loss: 0.117511, l2_loss: 796.310364, total loss: 0.173252, accuracy: 0.980000\n",
      "step 1500, entropy loss: 0.081443, l2_loss: 796.429443, total loss: 0.137193, accuracy: 0.990000\n",
      "step 1500, 训练误差:  0.956255\n",
      "step 1500, 测试误差:  0.960900\n",
      "step 1600, entropy loss: 0.247798, l2_loss: 796.556885, total loss: 0.303557, accuracy: 0.930000\n",
      "step 1700, entropy loss: 0.050467, l2_loss: 796.677002, total loss: 0.106234, accuracy: 1.000000\n",
      "step 1800, entropy loss: 0.143784, l2_loss: 796.779175, total loss: 0.199559, accuracy: 0.980000\n",
      "step 1900, entropy loss: 0.075613, l2_loss: 796.878235, total loss: 0.131395, accuracy: 0.990000\n",
      "step 2000, entropy loss: 0.082446, l2_loss: 796.954895, total loss: 0.138232, accuracy: 1.000000\n",
      "step 2000, 训练误差:  0.962418\n",
      "step 2000, 测试误差:  0.966300\n",
      "step 2100, entropy loss: 0.159252, l2_loss: 797.034668, total loss: 0.215045, accuracy: 0.970000\n",
      "step 2200, entropy loss: 0.103542, l2_loss: 797.114990, total loss: 0.159340, accuracy: 0.990000\n",
      "step 2300, entropy loss: 0.148060, l2_loss: 797.200317, total loss: 0.203864, accuracy: 0.980000\n",
      "step 2400, entropy loss: 0.165684, l2_loss: 797.267151, total loss: 0.221493, accuracy: 0.970000\n",
      "step 2500, entropy loss: 0.109861, l2_loss: 797.325439, total loss: 0.165673, accuracy: 0.980000\n",
      "step 2500, 训练误差:  0.969327\n",
      "step 2500, 测试误差:  0.972200\n",
      "step 2600, entropy loss: 0.089956, l2_loss: 797.387634, total loss: 0.145773, accuracy: 0.990000\n",
      "step 2700, entropy loss: 0.113078, l2_loss: 797.451355, total loss: 0.168899, accuracy: 0.980000\n",
      "step 2800, entropy loss: 0.057898, l2_loss: 797.510742, total loss: 0.113724, accuracy: 1.000000\n",
      "step 2900, entropy loss: 0.100392, l2_loss: 797.562744, total loss: 0.156221, accuracy: 0.980000\n",
      "step 3000, entropy loss: 0.121001, l2_loss: 797.588806, total loss: 0.176832, accuracy: 0.970000\n",
      "step 3000, 训练误差:  0.973109\n",
      "step 3000, 测试误差:  0.975100\n",
      "step 3100, entropy loss: 0.108133, l2_loss: 797.638855, total loss: 0.163968, accuracy: 0.970000\n",
      "step 3200, entropy loss: 0.071085, l2_loss: 797.679260, total loss: 0.126922, accuracy: 0.990000\n",
      "step 3300, entropy loss: 0.084632, l2_loss: 797.716736, total loss: 0.140472, accuracy: 0.980000\n",
      "step 3400, entropy loss: 0.074289, l2_loss: 797.752502, total loss: 0.130132, accuracy: 0.990000\n",
      "step 3500, entropy loss: 0.087725, l2_loss: 797.793762, total loss: 0.143571, accuracy: 0.990000\n",
      "step 3500, 训练误差:  0.975036\n",
      "step 3500, 测试误差:  0.976700\n",
      "step 3600, entropy loss: 0.047434, l2_loss: 797.835327, total loss: 0.103283, accuracy: 1.000000\n",
      "step 3700, entropy loss: 0.046782, l2_loss: 797.867249, total loss: 0.102633, accuracy: 1.000000\n",
      "step 3800, entropy loss: 0.031457, l2_loss: 797.875488, total loss: 0.087308, accuracy: 1.000000\n",
      "step 3900, entropy loss: 0.071354, l2_loss: 797.901611, total loss: 0.127207, accuracy: 1.000000\n",
      "step 4000, entropy loss: 0.086762, l2_loss: 797.912659, total loss: 0.142616, accuracy: 0.980000\n",
      "step 4000, 训练误差:  0.977836\n",
      "step 4000, 测试误差:  0.979400\n",
      "step 4100, entropy loss: 0.074608, l2_loss: 797.931091, total loss: 0.130463, accuracy: 0.990000\n",
      "step 4200, entropy loss: 0.050236, l2_loss: 797.966187, total loss: 0.106094, accuracy: 0.990000\n",
      "step 4300, entropy loss: 0.067882, l2_loss: 797.961975, total loss: 0.123739, accuracy: 0.990000\n",
      "step 4400, entropy loss: 0.063576, l2_loss: 797.979736, total loss: 0.119434, accuracy: 1.000000\n",
      "step 4500, entropy loss: 0.106639, l2_loss: 797.989990, total loss: 0.162498, accuracy: 0.960000\n",
      "step 4500, 训练误差:  0.981236\n",
      "step 4500, 测试误差:  0.980200\n",
      "step 4600, entropy loss: 0.035169, l2_loss: 797.993286, total loss: 0.091029, accuracy: 0.990000\n",
      "step 4700, entropy loss: 0.085065, l2_loss: 798.007751, total loss: 0.140926, accuracy: 0.990000\n",
      "step 4800, entropy loss: 0.026059, l2_loss: 798.024658, total loss: 0.081920, accuracy: 1.000000\n",
      "step 4900, entropy loss: 0.065867, l2_loss: 798.030029, total loss: 0.121729, accuracy: 1.000000\n",
      "step 5000, entropy loss: 0.054734, l2_loss: 798.013489, total loss: 0.110595, accuracy: 1.000000\n",
      "step 5000, 训练误差:  0.983036\n",
      "step 5000, 测试误差:  0.982300\n"
     ]
    }
   ],
   "source": [
    "init_op = tf.global_variables_initializer()\n",
    "sess.run(init_op)\n",
    "batch_size = 100\n",
    "acc_train_mat = []\n",
    "acc_test_mat = []\n",
    "loss_mat = []\n",
    "l2_loss_mat = []\n",
    "total_loss_mat = []\n",
    "# 训练\n",
    "for step in range(5000):    \n",
    "    batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "    # 学习速率\n",
    "    lr = 0.01\n",
    "    _, loss, l2_loss_value, total_loss_value = sess.run(\n",
    "               [train_step, cross_entropy, l2_loss, total_loss], \n",
    "               feed_dict={x: batch_xs, y_: batch_ys, learning_rate:lr})\n",
    "\n",
    "    if (step+1) % 100 == 0:     \n",
    "        # 测试模型\n",
    "        correct_prediction = tf.equal(tf.argmax(net, 1), tf.argmax(y_, 1))\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "        print('step %d, entropy loss: %f, l2_loss: %f, total loss: %f, accuracy: %f' % \n",
    "                (step+1, loss, l2_loss_value, total_loss_value, sess.run(accuracy, feed_dict={x: batch_xs, y_: batch_ys})))\n",
    "        loss_mat.append(loss)\n",
    "        l2_loss_mat.append(l2_loss_value)\n",
    "        total_loss_mat.append(total_loss_value)\n",
    "        \n",
    "        if (step+1) % 500 == 0:\n",
    "            # 计算训练误差，因显卡内存不足，故分批计算求平均值\n",
    "            train_size = mnist.train.images.shape\n",
    "            acc_batch = 0\n",
    "            acc = []\n",
    "            step_time = (int)(train_size[0]/batch_size)\n",
    "            for step_train in range(step_time):\n",
    "                batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "                acc_batch = sess.run(accuracy, feed_dict={x: batch_xs, y_: batch_ys})\n",
    "                acc.append(acc_batch)\n",
    "            step_acc_train = np.mean(acc)\n",
    "            print('step %d, 训练误差:  %f' % (step+1, step_acc_train))\n",
    "            acc_train_mat.append(step_acc_train)\n",
    "\n",
    "            # 计算测试误差，因显卡内存不足，故分批计算求平均值\n",
    "            test_size = mnist.test.images.shape\n",
    "            acc_batch = 0\n",
    "            acc = []\n",
    "            step_time = (int)(test_size[0]/batch_size)\n",
    "            for step_test in range(step_time):\n",
    "                batch_xs_test, batch_ys_test = mnist.test.next_batch(batch_size)\n",
    "                acc_batch = sess.run(accuracy, feed_dict={x: batch_xs_test, y_: batch_ys_test})\n",
    "                acc.append(acc_batch)\n",
    "            step_acc_test = np.mean(acc)\n",
    "            print('step %d, 测试误差:  %f' % (step+1, step_acc_test))\n",
    "            acc_test_mat.append(step_acc_test)\n",
    "#     if (step+1) % 1000 == 0:\n",
    "#         print(sess.run(accuracy, feed_dict={x: mnist.test.images,\n",
    "#                                         y_: mnist.test.labels}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#可视化\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(range(len(loss_mat)), loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_entropy_loss')\n",
    "plt.show() \n",
    "\n",
    "plt.plot(range(len(l2_loss_mat)), l2_loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_l2_loss')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(total_loss_mat)), total_loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_total_loss')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(acc_train_mat)), acc_train_mat, label='Train Accuracy') \n",
    "plt.plot(range(len(acc_test_mat)), acc_test_mat, label='Test Accuracy')\n",
    "plt.legend()\n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('accuracy')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "毫无疑问，这个模型是一个非常简陋，性能也不理想的模型。目前只能达到92%左右的准确率。\n",
    "接下来，希望大家利用现有的知识，将这个模型优化至98%以上的准确率。\n",
    "Hint：\n",
    "- 卷积\n",
    "- 池化\n",
    "- 激活函数\n",
    "- 正则化\n",
    "- 初始化\n",
    "- 摸索一下各个超参数\n",
    "  - 卷积kernel size\n",
    "  - 卷积kernel 数量\n",
    "  - 学习率\n",
    "  - 正则化惩罚因子\n",
    "  - 最好每隔几个step就对loss、accuracy等等进行一次输出，这样才能有根据地进行调整"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
